// Copyright (c) 2025, 大连理工大学 (Dalian University of Technology)
//
// Licensed under the Mulan PSL v2.
// You can use this file according to the terms and conditions of the Mulan PSL v2.
// You may obtain a copy of the License at
//
//     http://license.coscl.org.cn/MulanPSL2
//
// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. SEE THE MULAN PSL v2
// FOR MORE DETAILS.

// #include "DBManager/IService/Input/Node/INodeService.h"
// #include "DBManager/Service/Input/Element/CBARService.h"
// #include "DBManager/Service/Input/Constraint/RBE2Service.h"
// #include "DBManager/DBServiceFactory.h"
// #include "DBManager/Database/DatabaseFactory.h"

// #include <gtest/gtest.h>
// #include <vector>
// #include <set>
// #include <random>
// #include <chrono>
// using namespace SG::DBManager;

// class EfficiencyTest : public testing::Test
// {

//   public:
//     static const size_t million=200*100000;
//     static std::vector<SG::DataStructure::FEM::NodeData> nodes;//待写出的节点数据
//     static std::vector<SG::DataStructure::FEM::RBE2Data> RBE2s;//待写出的RBE2数据
//     static std::vector<SG::DataStructure::FEM::CBARData> CbarDatas;//待写出的CBAR数据

//     static std::vector<SG::DataStructure::Common::Id> nodeIds;         //待写出的节点id数据（由小到大排序）
//     static std::vector<SG::DataStructure::Common::Id> RBE2sIds;        //待写出的RBE2 id数据由小到大排序）
//     static std::vector<SG::DataStructure::Common::Id> CbarDatasIds;    //待写出的CBAR id数据由小到大排序）

//     static std::vector<SG::DataStructure::Common::Id> nodeIdsIndex;        // nodeIds的随机下标,
//     static std::vector<SG::DataStructure::Common::Id> RBE2sIdsIndex;       // RBE2sIds的随机下标
//     static std::vector<SG::DataStructure::Common::Id> CbarDatasIdsIndex;   // CbarDatasIds的随机下标
//     static std::shared_ptr<DBServiceFactory>       m_ConstraintSerSp;  //服务工厂

//     static void SetUpTestSuite ()
//     {
//         m_ConstraintSerSp=std::make_shared<DBServiceFactory>(*DatabaseFactory::GetDatabase(DatabaseFactory::HDF5,".","Efficiency.h5").get());
//         GenerateNodeData (1,1000,100);
//         GenerateRBE2s(10);
//         GenerateCbarDatas();
//         GenerateIdsIndex(nodes.size(),10000,nodeIdsIndex);
//         GenerateIdsIndex(RBE2s.size(),10000,RBE2sIdsIndex);
//         GenerateIdsIndex(CbarDatas.size(),10000,CbarDatasIdsIndex);
//     }

//     /// @brief 初始化节点数据
//     /// @param vectorSize  vector的size
//     /// @param blockSize   每块的尺寸
//     /// @return  IdIndexvector     返回向量
//     static void GenerateIdsIndex (size_t vectorSize,size_t blockSize,std::vector<SG::DataStructure::Common::Id>& IdIndexvector)
//     {
//         IdIndexvector.reserve(vectorSize);
//         // 使用随机设备作为种子来初始化随机数生成器
//         std::random_device              rd;
//         std::mt19937                    gen (rd ());  // Mersenne Twister 随机数生成器
//         int                             min = 0;
//         std::uniform_int_distribution<> distrib (min, blockSize-1);

//         size_t blockCount=vectorSize/blockSize;
//         for (size_t i = 0; i < blockCount; i++)
//         {
//             size_t beginIndex=i*blockSize;
//             for (size_t j = 0; j < blockSize; j++)
//             {
//                 IdIndexvector.push_back(distrib(gen)+beginIndex);
//             }

//         }
//     }
//     /// @brief 初始化节点数据
//     /// @param nodeSize  节点数量，百万计数
//     /// @param rMax       随机数上限制
//     /// @param  num      随机数区域对应的节点数量
//     static void GenerateNodeData (size_t nodeSize,size_t rMax,size_t num)
//     {
//         nodes.reserve(nodeSize*million);
//         // 使用随机设备作为种子来初始化随机数生成器
//         std::random_device              rd;
//         std::mt19937                    gen (rd ());  // Mersenne Twister 随机数生成器
//         int                             min = 1;
//         std::uniform_int_distribution<> distrib (min, rMax);
//         std::set<int> setInt;

//         //随机生成节点ID
//         while (setInt.size()<num)
//         {
//             setInt.insert(distrib(gen));
//         }

//         // 使用生成的随机ID填充nodes。并通过反向遍历set模拟无序状态
//         int counts=nodeSize*million/num;
//         SG::DataStructure::FEM::NodeData tempData={0};
//         for (int i = 0; i < counts; i++)
//         {
//             for (auto rit = setInt.rbegin (); rit != setInt.rend (); ++rit)
//             {
//                 tempData.m_id   = i * rMax + *rit;
//                 tempData.m_x[0] = tempData.m_id + 0.1;
//                 tempData.m_x[1] = tempData.m_id + 0.2;
//                 tempData.m_x[2] = tempData.m_id + 0.3;
//                 nodes.push_back (tempData);
//             }
//         }
//         std::cout<<nodes.size()<<"\n";
//     }

//     /// @brief 初始化Rbe2数据
//     /// @param period    多少节点数量作为一个Rb2
//     static void GenerateRBE2s (size_t period){
//         size_t counts=nodes.size()/period;//生成的RBE2单元数量
//         RBE2s.reserve(counts);
//         SG::DataStructure::FEM::RBE2Data rbe2Data={0};
//         rbe2Data.m_slaveDOFs=123456;

//         for (size_t i = 0; i < counts; i++)
//         {
//             rbe2Data.m_slaveNodes.clear();
//             rbe2Data.m_slaveNodes.reserve(period);
//             size_t beginIndex=i*period;
//             rbe2Data.m_id=nodes[beginIndex].m_id;
//             rbe2Data.m_masterNode=rbe2Data.m_id;

//             for (size_t j=1;j<period;j++)
//             {
//                 rbe2Data.m_slaveNodes.push_back(nodes[beginIndex+j].m_id);
//             }
//             RBE2s.push_back(rbe2Data);
//         }
//         std::cout<<RBE2s.size()<<"\n";
//     }

//     static void GenerateCbarDatas(){
//         SG::DataStructure::FEM::CBARData cbarData;
//         size_t count=nodes.size();
//         CbarDatas.reserve(count/2);

//         for (size_t i = 0; i <count; i+=2)
//         {
//             cbarData.m_id=nodes[i].m_id;
//             cbarData.m_g[0]=nodes[i].m_id;
//             cbarData.m_g[1]=nodes[i+1].m_id;
//             cbarData.m_x1=nodes[i].m_x[0]+1;
//             cbarData.m_x2=nodes[i].m_x[1];
//             cbarData.m_x3=nodes[i].m_x[2];
//             CbarDatas.push_back(cbarData);
//         }
//         std::cout<<CbarDatas.size()<<"\n";
//     }
// };

// std::vector<SG::DataStructure::FEM::NodeData> EfficiencyTest::nodes;
// std::vector<SG::DataStructure::FEM::RBE2Data> EfficiencyTest::RBE2s;
// std::vector<SG::DataStructure::FEM::CBARData> EfficiencyTest::CbarDatas;

// std::vector<SG::DataStructure::Common::Id> EfficiencyTest::nodeIds;
// std::vector<SG::DataStructure::Common::Id> EfficiencyTest::RBE2sIds;
// std::vector<SG::DataStructure::Common::Id> EfficiencyTest::CbarDatasIds;
// std::vector<SG::DataStructure::Common::Id> EfficiencyTest::nodeIdsIndex;
// std::vector<SG::DataStructure::Common::Id> EfficiencyTest::RBE2sIdsIndex;
// std::vector<SG::DataStructure::Common::Id> EfficiencyTest::CbarDatasIdsIndex;

// std::shared_ptr<DBServiceFactory> EfficiencyTest::m_ConstraintSerSp=nullptr;
// // TEST_F(EfficiencyTest, NodeWrite)
// // {

// //     auto start = std::chrono::high_resolution_clock::now();
// //     //主体函数
// //     auto nodeServecr=m_ConstraintSerSp->get<NodeService>();
// //     size_t count =nodes.size();
// //     for (size_t i = 0; i < count; i++)
// //     {
// //         nodeServecr->Add(nodes[i]);
// //     }
// //     nodeIds=nodeServecr->GetAllId ();

// //     auto end = std::chrono::high_resolution_clock::now();
// //     std::chrono::duration<double> duration = end - start;
// //     std::string outStr=std::string("write Node Size:")+std::to_string(count)+std::string("\n");
// //     outStr+=std::string("write Max Node Num:")+std::to_string(nodes.back().m_id)+std::string("\n");
// //     outStr+=std::string("Function run time:")+std::to_string(duration.count())+std::string("\n");
// //     std::cout << outStr << std::endl;

// //     std::sort (nodes.begin (), nodes.end ());
// // }

// // TEST_F(EfficiencyTest, Rb2Write)
// // {

// //     auto start = std::chrono::high_resolution_clock::now();

// //     //主体函数
// //     auto rbe2Servecr=m_ConstraintSerSp->get<RBE2Service>();
// //     size_t count =RBE2s.size();
// //     for (size_t i = 0; i < count; i++)
// //     {
// //         rbe2Servecr->Add(RBE2s[i]);
// //     }
// //     RBE2sIds=rbe2Servecr->GetAllId ();

// //     auto end = std::chrono::high_resolution_clock::now();
// //     std::chrono::duration<double> duration = end - start;
// //     std::string outStr=std::string("write RBE2s Size:")+std::to_string(count)+std::string("\n");
// //     outStr+=std::string("write Max RBE2s Num:")+std::to_string(RBE2s.back().m_id)+std::string("\n");
// //     outStr+=std::string("Function run time:")+std::to_string(duration.count())+std::string("\n");
// //     std::cout << outStr << std::endl;

// //     std::sort (RBE2s.begin (), RBE2s.end ());

// // }

// TEST_F(EfficiencyTest, CbarDataWrite)
// {

//     auto start = std::chrono::high_resolution_clock::now();
//     //主体函数
//     auto cbarServecr=m_ConstraintSerSp->get<CBARService>();
//     size_t count =CbarDatas.size();
//     for (size_t i = 0; i < count; i++)
//     {
//         cbarServecr->Add(CbarDatas[i]);
//     }
//     CbarDatasIds=cbarServecr->GetAllId ();

//     auto end = std::chrono::high_resolution_clock::now();
//     std::chrono::duration<double> duration = end - start;
//     std::string outStr=std::string("write CbarData Size:")+std::to_string(count)+std::string("\n");
//     outStr+=std::string("write Max CbarData Num:")+std::to_string(CbarDatas.back().m_id)+std::string("\n");
//     outStr+=std::string("Function run time:")+std::to_string(duration.count())+std::string("\n");
//     std::cout << outStr << std::endl;

//     std::sort (CbarDatas.begin (), CbarDatas.end ());
// }

// // TEST_F(EfficiencyTest, NodeFindByindex)
// // {
// //     size_t verifyIndex=nodes.size()/10;
// //     size_t verifyID=nodes[verifyIndex].m_id;

// //      //主体函数
// //     auto start = std::chrono::high_resolution_clock::now();
// //     auto nodeServecr=m_ConstraintSerSp->get<NodeService>();
// //     size_t count =nodes.size();
// //     for (size_t i = 0; i < count; i++)
// //     {
// //         nodes[i]=nodeServecr->FindByIndex(i);
// //     }

// //     auto end = std::chrono::high_resolution_clock::now();
// //     //验证
// //     ASSERT_EQ(verifyID, nodes[verifyIndex].m_id);

// //     std::chrono::duration<double> duration = end - start;
// //     std::string outStr=std::string("FindByindex Node Size:")+std::to_string(count)+std::string("\n");
// //     outStr+=std::string("Function run time:")+std::to_string(duration.count())+std::string("\n");
// //     outStr+=std::string("index:")+std::to_string(count/10)+std::string("ID:")+std::to_string(nodes[count/10].m_id)+std::string("\n");

// //     std::cout << outStr << std::endl;
// // }

// // TEST_F(EfficiencyTest, Rb2FindByindex)
// // {
// //     size_t verifyIndex=RBE2s.size()/10;
// //     size_t verifyID=RBE2s[verifyIndex].m_id;

// //     //主体函数
// //     auto start = std::chrono::high_resolution_clock::now();
// //     auto rbe2Servecr=m_ConstraintSerSp->get<RBE2Service>();
// //     size_t count =RBE2s.size();
// //     for (size_t i = 0; i < count; i++)
// //     {
// //         RBE2s[i]=rbe2Servecr->FindByIndex(i);
// //     }

// //     auto end = std::chrono::high_resolution_clock::now();
// //     std::chrono::duration<double> duration = end - start;

// //     //验证
// //     ASSERT_EQ(verifyID, RBE2s[verifyIndex].m_id);

// //     std::string outStr=std::string("FindByindex RBE2s Size:")+std::to_string(count)+std::string("\n");
// //     outStr+=std::string("Function run time:")+std::to_string(duration.count())+std::string("\n");
// //     outStr+=std::string("index:")+std::to_string(count/10)+std::string("ID:")+std::to_string(RBE2s[count/10].m_id)+std::string("\n");
// //     std::cout << outStr << std::endl;
// //     std::cout << RBE2s[count/10].m_slaveNodes[0] << std::endl;
// //     std::cout << RBE2s[count/10].m_slaveNodes[1] << std::endl;
// //     std::cout << RBE2s[count/10].m_slaveNodes[2] << std::endl;

// // }

// TEST_F(EfficiencyTest, CbarFindByindex)
// {
//     size_t verifyIndex=CbarDatas.size()/10;
//     size_t verifyID=CbarDatas[verifyIndex].m_id;

//     //主体函数
//     auto start = std::chrono::high_resolution_clock::now();
//     auto cbarServecr=m_ConstraintSerSp->get<CBARService>();
//     size_t count =CbarDatas.size();
//     for (size_t i = 0; i < count; i++)
//     {
//         CbarDatas[i]=cbarServecr->FindByIndex(i);
//     }
//     CbarDatasIds=cbarServecr->GetAllId ();

//     auto end = std::chrono::high_resolution_clock::now();
//     std::chrono::duration<double> duration = end - start;

//     //验证
//     ASSERT_EQ(verifyID, CbarDatas[verifyIndex].m_id);

//     std::string outStr=std::string("FindByindex CbarData Size:")+std::to_string(count)+std::string("\n");
//     outStr+=std::string("Function run time:")+std::to_string(duration.count())+std::string("\n");
//     outStr+=std::string("index:")+std::to_string(count/10)+std::string("ID:")+std::to_string(CbarDatas[count/10].m_id)+std::string("\n");
//     std::cout << outStr << std::endl;
//     std::cout << CbarDatas[count/10].m_g[0] << std::endl;
//     std::cout << CbarDatas[count/10].m_g[1] << std::endl;
// }

// // TEST_F(EfficiencyTest, NodeFindByid)
// // {
// //     size_t verifyIndex=nodeIdsIndex.size()/10;
// //     size_t verifyID=nodeIds[verifyIndex];

// //     auto start = std::chrono::high_resolution_clock::now();

// //     //主体函数
// //     auto nodeServecr=m_ConstraintSerSp->get<NodeService>();
// //     size_t count =nodes.size();
// //     SG::DataStructure::FEM::NodeData nodedata;
// //     for (size_t i = 0; i < count; i++)
// //     {
// //         size_t idIndex=nodeIdsIndex[i];
// //         nodeServecr->FindById(nodeIds[idIndex],nodedata);
// //     }

// //     auto end = std::chrono::high_resolution_clock::now();
// //     std::chrono::duration<double> duration = end - start;

// //     //验证
// //     nodeServecr->FindById(verifyID,nodedata);
// //     ASSERT_EQ(verifyID, nodedata.m_id);

// //     std::string outStr=std::string("FindByindex Node Size:")+std::to_string(count)+std::string("\n");
// //     outStr+=std::string("Function run time:")+std::to_string(duration.count())+std::string("\n");
// //     outStr+=std::string("ID:")+std::to_string(verifyID)+std::string("    FindID:")+std::to_string(nodedata.m_id)+std::string("\n");

// //     std::cout << outStr << std::endl;
// // }

// // TEST_F(EfficiencyTest, Rb2FindByid)
// // {
// //     size_t verifyIndex=RBE2sIdsIndex.size()/10;
// //     size_t verifyID=RBE2sIds[verifyIndex];

// //     auto start = std::chrono::high_resolution_clock::now();

// //     //主体函数
// //     auto rbe2Servecr=m_ConstraintSerSp->get<RBE2Service>();
// //     size_t count =RBE2s.size();
// //     SG::DataStructure::FEM::RBE2Data rbe2Data;
// //     for (size_t i = 0; i < count; i++)
// //     {
// //         size_t id = RBE2sIds[RBE2sIdsIndex[i]];
// //         rbe2Servecr->FindById(id,rbe2Data);
// //     }

// //     auto end = std::chrono::high_resolution_clock::now();
// //     std::chrono::duration<double> duration = end - start;

// //     //验证
// //     rbe2Servecr->FindById(verifyID,rbe2Data);
// //     ASSERT_EQ(verifyID, rbe2Data.m_id);

// //     std::string                   outStr   = std::string ("FindByindex RBE2s Size:") + std::to_string (count) + std::string ("\n");
// //     outStr += std::string ("Function run time:") + std::to_string (duration.count ()) + std::string ("\n");
// //     outStr+=std::string("ID:")+std::to_string(verifyID)+std::string("     FindID:")+std::to_string(rbe2Data.m_id)+std::string("\n");
// //     std::cout << outStr << std::endl;

// // }

// TEST_F(EfficiencyTest, CbarFindByid)
// {
//     size_t verifyIndex=CbarDatasIdsIndex.size()/10;
//     size_t verifyID=CbarDatasIds[verifyIndex];

//     auto start = std::chrono::high_resolution_clock::now();

//     //主体函数
//     auto cbarServecr=m_ConstraintSerSp->get<CBARService>();
//     size_t count =CbarDatas.size();
//     SG::DataStructure::FEM::CBARData cbarData;
//     for (size_t i = 0; i < count; i++)
//     {
//         size_t id = CbarDatasIds[CbarDatasIdsIndex[i]];
//         cbarServecr->FindById(id,cbarData);
//     }
//     CbarDatasIds=cbarServecr->GetAllId ();

//     auto end = std::chrono::high_resolution_clock::now();
//     std::chrono::duration<double> duration = end - start;

//     //验证
//     cbarServecr->FindById(verifyID,cbarData);
//     ASSERT_EQ(verifyID, cbarData.m_id);

//     std::string outStr=std::string("FindByindex CbarData Size:")+std::to_string(count)+std::string("\n");
//     outStr+=std::string("Function run time:")+std::to_string(duration.count())+std::string("\n");
//     outStr+=std::string("ID:")+std::to_string(verifyID)+std::string("    FindID:")+std::to_string(cbarData.m_id)+std::string("\n");

//     std::cout << outStr << std::endl;
//     std::cout << CbarDatas[count/10].m_g[0] << std::endl;
//     std::cout << CbarDatas[count/10].m_g[1] << std::endl;
// }